#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

class Edge
{
    public:
    int to;
    int w;
    Edge *next;
    void set(int to,int w)
    {
        this->to=to;
        this->w=w;
    }
};
class Graph
{
    static const int MVN=10000,MARCN=510*510*2;
    public:
    int vn,arcn;
    Edge *edge,*head[MVN];
    int ep;
    Graph()
    {
        init(0);
        edge=new Edge[MARCN];
    };
    void init(int n)
    {
        vn=n;
        arcn=ep=0;
        fill(head,head+MVN,(Edge*)NULL);
    }
    void addEdge(int vs,int vt,int w)
    {
        edge[ep].set(vt,w);
        edge[ep].next=head[vs];
        head[vs]=&edge[ep++];
        arcn++;
    }
};

inline int min(int a,int b){return a<b?a:b;}
inline int max(int a,int b){return a>b?a:b;}

class Tarjan
{
    static const int MVN=1010;
    public:
    int order[MVN],low[MVN],cnt;
    int gn[MVN],gi;
    Graph g,dag;
    vector<int> s;
    bool inStack[MVN];
    void init(Graph &g)
    {
        this->g=g;
        dag.init(0);
    }
    void dfs(int pos)
    {
        order[pos]=low[pos]=cnt++;
        s.push_back(pos),inStack[pos] = true;
        for(Edge *e=g.head[pos];e;e=e->next)
        {
            if(order[e->to]==-1)
            {
                dfs(e->to);
                if(low[e->to]<low[pos]) low[pos]=low[e->to];
            }
            else if(order[e->to]<low[pos]&&inStack[e->to]) low[pos]=order[e->to];
        }
        if(order[pos]==low[pos])
        {
            int t;
            while(!s.empty())
            {
                t=s.back(),s.pop_back(),inStack[t]=false;
                gn[t]=gi;
                if(t==pos) break;
            }
            gi++;
        }
    }
    void buildDag()
    {
        fill(order,order+g.vn,-1);
        fill(inStack,inStack+g.vn,false);
        fill(gn,gn+g.vn,-1),gi=0;
        s.clear();
        cnt = 0;
        for(int i=0;i<g.vn;i++) if(order[i]==-1)
            dfs(i);
      /*  for(int i=0;i<g.vn;i++)
            for(Edge *ep=g.head[i];ep;ep=ep->next)
                dag.addEdge(gn[i],gn[ep->to],0);
                */
    }
    bool legal()
    {
        for(int i=0;i<g.vn;i++) if(gn[i]==gn[i^1])
            return false;
        return true;
    }
};

bool cross(pair<int,int> a,pair<int,int> b)
{
    if(a.first>b.first)swap(a,b);
    if(a.second>b.first&&a.second<b.second) return true;
    else return false;
}
int main()
{
    int n,m;
    Graph g;
    Tarjan tarjan;
    pair<int,int> a[510],ai;
    cin>>n>>m;
    g.init(m*2);
    for(int i=0;i<m;i++)
    {
        int v1,v2;
        cin>>v1>>v2;
        if(v1>v2)swap(v1,v2);
        a[i].first=v1,a[i].second=v2;
        for(int j=0;j<i;j++) if(cross(a[i],a[j]))
        {
            g.addEdge(i*2,j*2+1,0);
            g.addEdge(i*2+1,j*2,0);
            g.addEdge(j*2+1,i*2,0);
            g.addEdge(j*2,i*2+1,0);
        }
    }
    tarjan.init(g);
    tarjan.buildDag();
    if(tarjan.legal()) cout<<"panda is telling the truth..."<<endl;
    else cout<<"the evil panda is lying again";
    return 0;
}
